import type { Page } from '#/types';

import { requestClient } from '#/api/request';

export namespace LowcodeDatasourceApi {
  /** 动态数据源配置 */
  export interface DatasourceConfig {
    id?: number;
    name: string;
    type: string;
    url: string;
    username: string;
    password?: string;
    driverClassName: string;
    initialSize?: number;
    minIdle?: number;
    maxActive?: number;
    testQuery?: string;
    status: number;
    createTime?: string;
    updateTime?: string;
  }

  /** 数据源连接测试结果 */
  export interface ConnectionTestResult {
    success: boolean;
    message: string;
    responseTime?: number;
  }

  /** 数据源健康检查结果 */
  export interface HealthCheckResult {
    healthy: boolean;
    activeConnections: number;
    idleConnections: number;
    maxConnections: number;
    details?: string;
  }

  /** 数据库表信息 */
  export interface DatabaseTable {
    tableName: string;
    tableComment?: string;
    tableType?: string;
    engine?: string;
    createTime?: string;
    updateTime?: string;
  }

  /** Magic API同步结果 */
  export interface SyncMagicApiResult {
    success: boolean;
    message: string;
    syncedCount?: number;
    failedCount?: number;
    details?: string[];
  }
}

/** 获取数据源配置分页列表 */
export function getDatasourceConfigPage(params: any) {
  return requestClient.get<Page<LowcodeDatasourceApi.DatasourceConfig>>(
    '/lowcode/data-source-config/page',
    {
      params,
    },
  );
}

/** 获取数据源配置详情 */
export function getDatasourceConfig(id: number) {
  if (!id || id <= 0) {
    return Promise.reject(new Error('无效的数据源ID'));
  }

  return requestClient.get<LowcodeDatasourceApi.DatasourceConfig>(
    `/lowcode/data-source-config/get`,
    {
      params: { id },
    },
  );
}

/** 新增数据源配置 */
export function createDatasourceConfig(
  data: LowcodeDatasourceApi.DatasourceConfig,
) {
  // 数据验证
  if (!data.name?.trim()) {
    return Promise.reject(new Error('数据源名称不能为空'));
  }
  if (!data.type?.trim()) {
    return Promise.reject(new Error('数据源类型不能为空'));
  }
  if (!data.url?.trim()) {
    return Promise.reject(new Error('数据源URL不能为空'));
  }
  if (!data.username?.trim()) {
    return Promise.reject(new Error('用户名不能为空'));
  }

  // 验证数值范围
  if (data.initialSize && (data.initialSize < 0 || data.initialSize > 100)) {
    return Promise.reject(new Error('初始连接数应在0-100之间'));
  }
  if (data.minIdle && (data.minIdle < 0 || data.minIdle > 100)) {
    return Promise.reject(new Error('最小空闲连接数应在0-100之间'));
  }
  if (data.maxActive && (data.maxActive < 1 || data.maxActive > 1000)) {
    return Promise.reject(new Error('最大活跃连接数应在1-1000之间'));
  }

  return requestClient.post('/lowcode/data-source-config/create', data);
}

/** 修改数据源配置 */
export function updateDatasourceConfig(
  data: LowcodeDatasourceApi.DatasourceConfig,
) {
  // 数据验证（同创建时的验证）
  if (!data.id) {
    return Promise.reject(new Error('数据源ID不能为空'));
  }
  if (!data.name?.trim()) {
    return Promise.reject(new Error('数据源名称不能为空'));
  }
  if (!data.type?.trim()) {
    return Promise.reject(new Error('数据源类型不能为空'));
  }
  if (!data.url?.trim()) {
    return Promise.reject(new Error('数据源URL不能为空'));
  }
  if (!data.username?.trim()) {
    return Promise.reject(new Error('用户名不能为空'));
  }

  // 验证数值范围
  if (data.initialSize && (data.initialSize < 0 || data.initialSize > 100)) {
    return Promise.reject(new Error('初始连接数应在0-100之间'));
  }
  if (data.minIdle && (data.minIdle < 0 || data.minIdle > 100)) {
    return Promise.reject(new Error('最小空闲连接数应在0-100之间'));
  }
  if (data.maxActive && (data.maxActive < 1 || data.maxActive > 1000)) {
    return Promise.reject(new Error('最大活跃连接数应在1-1000之间'));
  }

  return requestClient.put('/lowcode/data-source-config/update', data);
}

/** 删除数据源配置 */
export function deleteDatasourceConfig(id: number) {
  if (!id || id <= 0) {
    return Promise.reject(new Error('无效的数据源ID'));
  }

  return requestClient.delete(`/lowcode/data-source-config/delete`, {
    params: { id },
  });
}

/** 测试数据源连接 */
export function testDatasourceConnection(
  data: LowcodeDatasourceApi.DatasourceConfig,
) {
  // 验证必要字段
  if (!data.name?.trim()) {
    return Promise.reject(new Error('数据源名称不能为空'));
  }
  if (!data.type?.trim()) {
    return Promise.reject(new Error('数据源类型不能为空'));
  }
  if (!data.url?.trim()) {
    return Promise.reject(new Error('数据源URL不能为空'));
  }
  if (!data.username?.trim()) {
    return Promise.reject(new Error('用户名不能为空'));
  }

  // 验证URL格式（基本检查）
  try {
    const url = new URL(data.url);
    const allowedProtocols = [
      'jdbc:mysql:',
      'jdbc:postgresql:',
      'jdbc:oracle:',
      'jdbc:sqlserver:',
    ];
    const hasValidProtocol = allowedProtocols.some((protocol) =>
      data.url.startsWith(protocol),
    );
    if (!hasValidProtocol) {
      return Promise.reject(new Error('不支持的数据库连接协议'));
    }
  } catch {
    // JDBC URL可能不符合标准URL格式，进行基本检查
    if (!data.url.startsWith('jdbc:')) {
      return Promise.reject(new Error('数据源URL格式错误'));
    }
  }

  return requestClient.post<LowcodeDatasourceApi.ConnectionTestResult>(
    '/lowcode/data-source-config/test-connection',
    data,
  );
}

/** 获取数据源健康状态 */
export function getDatasourceHealth(id: number) {
  if (!id || id <= 0) {
    return Promise.reject(new Error('无效的数据源ID'));
  }

  return requestClient.get<LowcodeDatasourceApi.HealthCheckResult>(
    `/lowcode/data-source-config/health/${id}`,
  );
}

/** 切换数据源状态 */
export function updateDatasourceStatus(id: number, status: number) {
  if (!id || id <= 0) {
    return Promise.reject(new Error('无效的数据源ID'));
  }

  if (![0, 1].includes(status)) {
    return Promise.reject(new Error('无效的状态值'));
  }

  return requestClient.post(
    '/lowcode/data-source-config/update-status',
    {},
    {
      params: { id, status },
    },
  );
}

/** 获取支持的数据库类型列表 */
export function getSupportedDatabaseTypes() {
  return requestClient.get<string[]>(
    '/lowcode/data-source-config/supported-types',
  );
}

// ============ 新增的核心接口 ============

/** 获取启用的数据源列表 */
export function getEnabledDatasourceList() {
  return requestClient.get<LowcodeDatasourceApi.DatasourceConfig[]>(
    '/lowcode/data-source-config/list-enabled',
  );
}

/** 同步数据源到Magic API */
export function syncMagicApiDatasource(dataSourceId?: number) {
  return requestClient.post<LowcodeDatasourceApi.SyncMagicApiResult>(
    '/lowcode/data-source-config/sync-magic-api-datasource',
    {},
    {
      params: dataSourceId ? { dataSourceId } : {},
    },
  );
}

/** 获取数据源的表列表 */
export function getDatasourceTables(dataSourceId: number) {
  if (!dataSourceId || dataSourceId <= 0) {
    return Promise.reject(new Error('无效的数据源ID'));
  }

  return requestClient.get<LowcodeDatasourceApi.DatabaseTable[]>(
    '/lowcode/data-source-config/tables',
    {
      params: { id: dataSourceId },
    },
  );
}

// ============ 同步管理工具函数 ============

/** 
 * 数据源变更后的同步处理
 * @param operation 操作类型：create | update | delete
 * @param dataSourceId 数据源ID（删除时可选）
 * @param autoSync 是否自动同步，默认false
 * @returns 同步结果
 */
export async function handleDatasourceSync(
  operation: 'create' | 'update' | 'delete',
  dataSourceId?: number,
  autoSync: boolean = false
): Promise<{
  needSync: boolean;
  syncResult?: LowcodeDatasourceApi.SyncMagicApiResult;
  message: string;
}> {
  const operationNames = {
    create: '创建',
    update: '修改', 
    delete: '删除'
  };
  
  const opName = operationNames[operation];
  
  if (autoSync) {
    try {
      const syncResult = await syncMagicApiDatasource(dataSourceId);
      return {
        needSync: false,
        syncResult,
        message: `${opName}成功并已自动同步到Magic API`
      };
    } catch (error) {
      return {
        needSync: true,
        message: `${opName}成功，但同步到Magic API失败。请手动点击同步按钮或重启应用使配置生效。`
      };
    }
  } else {
    return {
      needSync: true,
      message: `${opName}成功！请注意：数据源修改后需要同步才能在Magic API中生效。您可以：\n1. 点击"同步到Magic API"按钮\n2. 重启应用`
    };
  }
}
